import { defineStore } from 'pinia'
import { useUserStore } from './user'
import { constantRoutes } from '../router'
import { ElMessage } from 'element-plus'

/**
 * 使用递归过滤路由表
 * @param {Array} menuTree - 权限菜单树
 * @returns {Array} 过滤后的路由表
 */
function filterAsyncRoutes(menuTree) {
  const res = []

  menuTree.forEach(menu => {
    const route = generateRoute(menu)
    if (route) {
      // 如果有子路由
      if (menu.children && menu.children.length > 0) {
        // 递归处理子路由
        route.children = filterAsyncRoutes(menu.children)
      }
      res.push(route)
    }
  })

  return res
}

/**
 * 根据权限菜单生成路由
 * @param {Object} menu - 权限菜单
 * @returns {Object} 路由对象
 */
function generateRoute(menu) {
  // 只处理 permissionType 为 0(目录) 或 1(菜单) 的权限
  if (menu.permissionType !== 0 && menu.permissionType !== 1) {
    return null
  }
  
  // 生成路由对象
  const route = {
    path: menu.routerPath,
    name: menu.permissionCode,
    meta: {
      title: menu.permissionName,
      icon: menu.icon,
      // 将原始菜单信息保存在meta中
      menu: menu,
      // 添加isShow字段
      isShow: menu.isShow === undefined ? true : !!menu.isShow
    }
  }
  
  // 目录类型
  // if (menu.permissionType === 0) {
  //   // 目录需要使用Layout组件作为父级
  //   route.component = () => import('../layout/index.vue')
  // } 
  // // 菜单类型
  // else if (menu.permissionType === 1) {
  //   // 获取组件路径
  //   const componentPath = menu.component
  //   // 动态导入组件
  //   if (componentPath) {
  //     // 通过Vite的import.meta.glob预先导入所有组件
  //     const modules = import.meta.glob('../views/**/*.vue')
      
  //     // 构建可能的路径
  //     let fullPath = ''
  //     if (componentPath.startsWith('/')) {
  //       // 以/开头的路径从src开始
  //       fullPath = `../views${componentPath}.vue`
  //     } else {
  //       // 相对路径
  //       fullPath = `../views/${componentPath}.vue`
  //     }
  //     console.log('尝试加载的组件路径:', fullPath)
      
  //     // 查找匹配的组件
  //     if (modules[fullPath]) {
  //       route.component = modules[fullPath] // 这是一个函数，会返回一个Promise
  //       console.log('成功找到组件:', fullPath)
  //     } else {
  //       console.warn(`组件路径 ${fullPath} 不存在，使用默认组件代替`)
  //       const homeModule = import.meta.glob('../views/HomePage.vue')
  //       route.component = homeModule['../views/HomePage.vue']
  //     }
  //   } else {
  //     // 如果没有组件路径，则使用默认空白页
  //     const homeModule = import.meta.glob('../views/HomePage.vue')
  //     route.component = homeModule['../views/HomePage.vue']
  //   }
  // }
  
  return route
}

/**
 * 根据权限树生成菜单数据
 * @param {Array} menuTree - 权限菜单树
 * @returns {Array} 菜单数据
 */
function generateMenu(menuTree) {
  const menus = []
  
  menuTree.forEach(item => {
    // 只处理目录和菜单类型，且isShow不为0的项目
    if ((item.permissionType === 0 || item.permissionType === 1) && item.isShow !== 0) {
      const menu = {
        path: item.routerPath,
        name: item.permissionName,
        icon: item.icon || 'Document',
        permissionCode: item.permissionCode
      }
      
      // 处理子菜单
      if (item.children && item.children.length > 0) {
        menu.children = generateMenu(item.children)
      }
      
      menus.push(menu)
    }
  })
  
  return menus
}

export const usePermissionStore = defineStore('permission', {
  state: () => ({
    routes: [],        // 所有路由
    addRoutes: [],     // 动态添加的路由
    menuData: [],      // 菜单数据
    // 按钮权限映射表，键为permissionCode，值为true
    buttonPermissions: {},
    // 接口权限映射表，键为路径+方法，值为true
    apiPermissions: {}
  }),
  
  getters: {
    // 获取所有菜单数据
    menus: (state) => state.menuData,
    
    // 获取一级菜单数据，供侧边栏一级菜单使用
    firstLevelMenus: (state) => {
      return state.menuData.map(menu => ({
        path: menu.path,
        name: menu.name,
        icon: menu.icon
      }))
    },
    
    // 获取子菜单数据，根据一级菜单路径获取对应的子菜单
    getSubMenusByPath: (state) => (path) => {
      const menu = state.menuData.find(menu => menu.path === path)
      return menu ? menu.children || [] : []
    },
    
    // 检查是否有按钮权限
    hasButtonPermission: (state) => (permissionCode) => {
      return !!state.buttonPermissions[permissionCode]
    },
    
    // 检查是否有API权限
    hasApiPermission: (state) => (path, method) => {
      return !!state.apiPermissions[`${path}:${method}`]
    }
  },
  
  actions: {
    // 生成路由
    generateRoutes() {
      return new Promise(resolve => {
        const userStore = useUserStore()
        const { menuTree } = userStore
        
        if (!menuTree || menuTree.length === 0) {
          // 如果没有权限菜单，使用默认路由
          this.routes = constantRoutes
          this.addRoutes = []
          this.menuData = []
          resolve([])
          return
        }
        
        try {
          // 生成动态路由
          const accessedRoutes = filterAsyncRoutes(menuTree)
          // 生成菜单数据
          this.menuData = generateMenu(menuTree)
          // 更新路由
          this.addRoutes = accessedRoutes
          this.routes = constantRoutes.concat(accessedRoutes)
          
          // 处理按钮和接口权限
          this.processPermissions(menuTree)
          
          resolve(accessedRoutes)
        } catch (error) {
          console.error('生成路由出错:', error)
          ElMessage.error('生成路由出错，请联系管理员')
          this.routes = constantRoutes
          this.addRoutes = []
          this.menuData = []
          resolve([])
        }
      })
    },
    
    /**
     * 处理权限数据，提取按钮和接口权限
     * @param {Array} menuTree - 权限菜单树
     */
    processPermissions(menuTree) {
      const buttonPerms = {}
      const apiPerms = {}
      
      // 递归处理
      const processTree = (tree) => {
        if (!tree || !tree.length) return
        
        tree.forEach(item => {
          // 处理按钮权限 (permissionType = 2)
          if (item.permissionType === 2 && item.permissionCode) {
            buttonPerms[item.permissionCode] = true
          }
          
          // 处理接口权限 (permissionType = 3)
          if (item.permissionType === 3 && item.requestPath && item.requestMethod) {
            apiPerms[`${item.requestPath}:${item.requestMethod}`] = true
          }
          
          // 递归处理子权限
          if (item.children && item.children.length) {
            processTree(item.children)
          }
        })
      }
      
      processTree(menuTree)
      
      // 更新到state
      this.buttonPermissions = buttonPerms
      this.apiPermissions = apiPerms
    },
    
    // 重置路由
    resetRoutes() {
      this.routes = []
      this.addRoutes = []
      this.menuData = []
      this.buttonPermissions = {}
      this.apiPermissions = {}
    }
  }
}) 
//  Pinia 的 usePermissionStore Store，用于根据用户权限动态生成前端路由和菜单，并处理按钮与接口权限控制。核心功能如下：

// filterAsyncRoutes：递归过滤权限菜单树，生成对应的路由数组。
// generateRoute：将权限菜单对象转换为 Vue Router 路由对象，支持动态导入组件。
// generateMenu：从权限菜单树中提取显示用的菜单数据。
// usePermissionStore：
// 存储路由、菜单、按钮权限、接口权限等状态。
// 提供 generateRoutes 方法异步生成路由并更新菜单和权限。
// 提供 hasButtonPermission 和 hasApiPermission 检查权限。
// 提供 resetRoutes 重置所有权限相关状态。